home *** CD-ROM | disk | FTP | other *** search
/ The Guided Tour of Multimedia (Second Edition) / The Guided Tour of Multimedia (Second Edition).iso / trials / director / evalcopy / director.z / WIDGET.C < prev    next >
C/C++ Source or Header  |  1994-06-02  |  16KB  |  505 lines
  1. /*****************************************************************************
  2.  
  3.                            Macromedia Widget XObject
  4.                   Sample code for Director Windows Player 3.1
  5.                                        
  6.                          (c) Copyright 1993 Macromedia
  7.                               All Rights Reserved
  8.  
  9.  
  10.                Sample code and XObject documentation prepared by
  11.                       Patrick Milligan of Oakleaf Designs
  12.                                    
  13.               Direct your comments to him via AppleLink: OAKLEAF,
  14.                    Phone: 408-257-1547, or Fax: 408-996-9432
  15.  
  16.  *****************************************************************************/
  17.  
  18. #include <windows.h>
  19. #include "XObject.h"
  20.  
  21. /*
  22. ------------------------------------------------------------------------------
  23. Method Function Prototypes:
  24. ------------------------------------------------------------------------------
  25. */
  26.  
  27. short __far __pascal __export LibMain(
  28.     HANDLE hndInstance, WORD wDataSeg, WORD cbHeapSize, DWORD ignore);
  29. //DJ20jul93int __export __far __pascal WEP(int nParameter);
  30. long __far __pascal __export _widget_mNew(
  31.     LxProcTablePtr xtbl, LxMemHandle hWidget);
  32. long __far __pascal __export _widget_mDispose(
  33.     LxProcTablePtr xtbl, LxMemHandle hWidget); 
  34. LxMemHandle __far __pascal __export _widget_mName(
  35.     LxProcTablePtr xtbl, LxMemHandle hWidget);
  36. long __far __pascal __export _widget_mStatus(
  37.     LxProcTablePtr xtbl, LxMemHandle hWidget);
  38. LxMemHandle __far __pascal __export _widget_mError(
  39.     long lErrorCode, LxProcTablePtr xtbl, LxMemHandle hWidget);
  40. LxMemHandle __far __pascal __export _widget_mLastError(
  41.     LxProcTablePtr xtbl, LxMemHandle hWidget);
  42. long __far __pascal __export _widget_mAdd(
  43.     long arg1, long arg2, LxProcTablePtr xtbl, LxMemHandle hWidget);
  44. LxMemHandle __far __pascal __export _widget_mFirst(
  45.     LxMemHandle hStrIn, long nChars, LxProcTablePtr xtbl, LxMemHandle hWidget);
  46. long __far __pascal __export _widget_mMul(
  47.     long nArgs, LxValuePtr argp, LxProcTablePtr xtbl, LxMemHandle hWidget);
  48. long __far __pascal __export _widget_mGlobals(
  49.     LxProcTablePtr xtbl, LxMemHandle hWidget);
  50. long __far __pascal __export _widget_mSymbols(
  51.     LxProcTablePtr xtbl, LxMemHandle hWidget);
  52. long __far __pascal __export _widget_mSendPerform(
  53.     LxProcTablePtr xtbl, LxMemHandle hWidget);
  54. long __far __pascal __export _widget_mFactory(
  55.     LxProcTablePtr xtbl, LxMemHandle hWidget);
  56.  
  57.  
  58. /*
  59. ------------------------------------------------------------------------------
  60. Constants:
  61. ------------------------------------------------------------------------------
  62. */
  63.  
  64. #define WIDGET_SUCCESS          0       // Successful return code
  65. #define WIDGET_MEM_ALLOC        1       // Memory allocation error
  66.  
  67. /*
  68. ------------------------------------------------------------------------------
  69. Types:
  70. ------------------------------------------------------------------------------
  71. */
  72.  
  73. typedef struct
  74. {
  75.     LxXObjHeader        head;           // Required XObject header
  76.     LxMemHandle         hErrMsg;        // Sample instance data: handle
  77.     short               sJunk;          // Sample instance data: short
  78. }   WidgetType, FAR *pWidgetType;
  79.  
  80.  
  81. /*
  82. ------------------------------------------------------------------------------
  83. Variables:
  84. ------------------------------------------------------------------------------
  85. */
  86.  
  87. long    lWidgetError = WIDGET_SUCCESS;
  88. HANDLE  hInst;
  89.  
  90.  
  91. /*
  92. ------------------------------------------------------------------------------
  93. FUNCTION        ||      LibMain()
  94.  
  95. Windows Entry Procedure for DLLs.  Called by LibEntry routine.
  96. ------------------------------------------------------------------------------
  97. */
  98.  
  99. short __far __pascal __export LibMain(
  100.     HANDLE hndInstance, WORD wDataSeg, WORD cbHeapSize, DWORD ignore)
  101. {
  102.     if (cbHeapSize != 0)
  103.     {
  104.         if (! LocalInit( (UINT)wDataSeg, (UINT)NULL, (UINT)cbHeapSize))
  105.         {
  106.             return (0);
  107.         }
  108.     }
  109.     hInst = hndInstance;
  110.     return (1);
  111. }
  112.  
  113.  
  114. //DJ20jul93/*
  115. //DJ20jul93------------------------------------------------------------------------------
  116. //DJ20jul93FUNCTION        ||      WEP()
  117. //DJ20jul93
  118. //DJ20jul93Windows Exit Procedure for DLLs.
  119. //DJ20jul93------------------------------------------------------------------------------
  120. //DJ20jul93*/
  121. //DJ20jul93int __export __far __pascal WEP(int nParameter)
  122. //DJ20jul93{
  123. //DJ20jul93    return 1;
  124. //DJ20jul93}
  125.  
  126.  
  127. /*
  128. ------------------------------------------------------------------------------
  129. Internal Functions:
  130. ------------------------------------------------------------------------------
  131. */
  132.  
  133. // Log some useful debug info to message window
  134. static void LogMessage( LxProcTablePtr xtbl, const char *format, ...)
  135. {
  136.     char    buf[250];               // !!@ No error check on size.
  137.  
  138.     wvsprintf( buf, format, ((char *)&format)+sizeof(char *) );
  139.     xtbl->showMsg( buf );
  140. }
  141.  
  142.  
  143. /*
  144. ------------------------------------------------------------------------------
  145. Macros:
  146. ------------------------------------------------------------------------------
  147. */
  148.  
  149.  
  150. /*
  151. ------------------------------------------------------------------------------
  152. FUNCTION        ||      _widget_mNew
  153.  
  154. Create a new instance of the Widget XObject.  Initialize instance variables.
  155. ------------------------------------------------------------------------------
  156. */
  157.  
  158. long __far __pascal __export _widget_mNew(
  159.     LxProcTablePtr xtbl, LxMemHandle hWidget)
  160. {
  161.     pWidgetType pWidget;
  162.     
  163.     lWidgetError = WIDGET_SUCCESS;
  164.  
  165.     if ( xtbl->mem_SetSize(hWidget, (long) sizeof(WidgetType) )  != NULL)
  166.     {
  167.         // Initialize instance data
  168.         pWidget = xtbl->mem_Lock(hWidget);
  169.         pWidget->hErrMsg = NULL;
  170.         pWidget->sJunk = -1;
  171.         xtbl->mem_Unlock(hWidget);
  172.     }
  173.     else
  174.     {
  175.         lWidgetError = WIDGET_MEM_ALLOC;
  176.     }
  177.     return (lWidgetError);
  178. }
  179.  
  180. /*
  181. -----------------------------------------------------------------------------
  182. FUNCTION       ||      _widget_mDispose
  183.  
  184. Dispose of a Widget XObject instance.  Free instance data (if any).
  185. -----------------------------------------------------------------------------
  186. */
  187. long __far __pascal __export _widget_mDispose(
  188.     LxProcTablePtr xtbl, LxMemHandle hWidget)
  189. {
  190.     pWidgetType pWidget;
  191.  
  192.     lWidgetError = WIDGET_SUCCESS;
  193.     pWidget = xtbl->mem_Lock(hWidget);
  194.     if (pWidget->hErrMsg != NULL)
  195.     {
  196.         // Dispose of saved error message:
  197.         xtbl->mem_Dispose(pWidget->hErrMsg);
  198.     }
  199.     xtbl->mem_Unlock(hWidget);
  200.     xtbl->xobj_Dispose(hWidget);
  201.     return (lWidgetError);
  202. }
  203.  
  204. /*
  205. ------------------------------------------------------------------------------
  206. FUNCTION        ||      _widget_mName
  207.  
  208. Return the name of this XObject (e.g. "Widget")
  209. ------------------------------------------------------------------------------
  210. */
  211.  
  212. LxMemHandle __far __pascal __export _widget_mName(
  213.     LxProcTablePtr xtbl, LxMemHandle hWidget)
  214. {
  215.     return (xtbl->string_New("Widget"));
  216. }
  217.  
  218. /*
  219. ------------------------------------------------------------------------------
  220. FUNCTION        ||      _widget_mStatus
  221.  
  222. Return the integer status code from the last Method call.
  223. ------------------------------------------------------------------------------
  224. */
  225.  
  226. long __far __pascal __export _widget_mStatus(
  227.     LxProcTablePtr xtbl, LxMemHandle hWidget)
  228. {
  229.     return (lWidgetError);
  230. }
  231.  
  232. /*
  233. ------------------------------------------------------------------------------
  234. FUNCTION        ||      _widget_mError
  235.  
  236. Return an error string corresponding to the passed error code.
  237. ------------------------------------------------------------------------------
  238. */
  239.  
  240. LxMemHandle __far __pascal __export _widget_mError(
  241.     long lErrorCode, LxProcTablePtr xtbl, LxMemHandle hWidget)
  242. {
  243.     LPSTR       pStrMsg;
  244.     LxMemHandle hStrMsg;
  245.     pWidgetType pWidget;
  246.  
  247.     switch ((short) lErrorCode)
  248.     {
  249.         case WIDGET_SUCCESS:
  250.             pStrMsg = "";
  251.             break;
  252.         case WIDGET_MEM_ALLOC:
  253.             pStrMsg = "Memory allocation failure";
  254.             break;
  255.         default:
  256.             pStrMsg = "Unknown error";
  257.             break;
  258.     }
  259.     hStrMsg = xtbl->string_New(pStrMsg);
  260.  
  261.     // Save a copy of returned string in instance variable
  262.     pWidget = xtbl->mem_Lock(hWidget);
  263.     pWidget->hErrMsg = xtbl->mem_Clone(hStrMsg);
  264.     xtbl->mem_Unlock(hWidget);
  265.  
  266.     return (hStrMsg);
  267. }
  268.  
  269. /*
  270. ------------------------------------------------------------------------------
  271. FUNCTION        ||      _widget_mLastError
  272.  
  273. Return the last error message string returned by mError.
  274. ------------------------------------------------------------------------------
  275. */
  276.  
  277. LxMemHandle __far __pascal __export _widget_mLastError(
  278.     LxProcTablePtr xtbl, LxMemHandle hWidget)
  279. {
  280.     pWidgetType pWidget;
  281.     LxMemHandle hStrMsg;
  282.  
  283.     pWidget = xtbl->mem_Lock(hWidget);  // Lock Object instance
  284.     if (pWidget->hErrMsg != NULL)
  285.     {
  286.         hStrMsg = xtbl->mem_Clone(pWidget->hErrMsg);
  287.     }
  288.     else
  289.     {
  290.         hStrMsg = xtbl->string_New("");
  291.     }
  292.     xtbl->mem_Unlock(hWidget);  // Unlock Object instance
  293.  
  294.     return (hStrMsg);
  295. }
  296.  
  297. /*
  298. ------------------------------------------------------------------------------
  299. FUNCTION        ||      _widget_mAdd
  300.  
  301. Add two integers (arg1 and arg2) and return the integer result.
  302. ------------------------------------------------------------------------------
  303. */
  304.  
  305. long __far __pascal __export _widget_mAdd(
  306.     long arg1, long arg2, LxProcTablePtr xtbl, LxMemHandle hWidget)
  307. {
  308.     return (arg1 + arg2);
  309. }
  310.  
  311. /*
  312. ------------------------------------------------------------------------------
  313. FUNCTION        ||      _widget_mFirst
  314.  
  315. Return a string containing the first nChars characters of string hStrIn.
  316. ------------------------------------------------------------------------------
  317. */
  318.  
  319. LxMemHandle __far __pascal __export _widget_mFirst(
  320.     LxMemHandle hStrIn, long nChars, LxProcTablePtr xtbl, LxMemHandle hWidget)
  321. {
  322.     LPSTR       pStrIn;
  323.     LxMemHandle hStrOut;
  324.     LPSTR       pStrOut;
  325.     
  326.     hStrOut = xtbl->mem_New(nChars+1, TRUE);    // Zero fill 
  327.  
  328.     pStrOut = xtbl->mem_Lock(hStrOut);          // Lock handles
  329.     pStrIn  = xtbl->mem_Lock(hStrIn);
  330.  
  331.     xtbl->mem_Copy(pStrOut, pStrIn, nChars);    // Copy substring
  332.  
  333.     xtbl->mem_Unlock(hStrOut);                  // Unlock handles
  334.     xtbl->mem_Unlock(hStrIn);
  335.     
  336.     return (hStrOut);
  337. }
  338.  
  339. /*
  340. ------------------------------------------------------------------------------
  341. FUNCTION        ||      _widget_mMul
  342.  
  343. Return floating point result (long double) which is the product of the two
  344. passed floating point inputs (f1 and f2).  Demonstrates V-type methods.
  345. ------------------------------------------------------------------------------
  346. */
  347.  
  348. long __far __pascal __export _widget_mMul(
  349.     long nArgs, LxValuePtr argp, LxProcTablePtr xtbl, LxMemHandle hWidget)
  350. {
  351.     long double         f1, f2, f3;
  352.     long double**       returnFloat;
  353.  
  354.     if (nArgs == 2)
  355.     {       
  356.         if (argp[1].ty == TY_FLOAT)
  357.         {
  358.             f1 = **(long double**) argp[1].it;  // Get first argument
  359.         }
  360.         else
  361.         {
  362.             xtbl->showMsg("First argument is not floating point\n");
  363.             f1 = 0.0;
  364.         }
  365.         if (argp[2].ty == TY_FLOAT)
  366.         {
  367.             f2 = **(long double**) argp[2].it;  // Get second argument
  368.         }
  369.         else
  370.         {
  371.             xtbl->showMsg("Second argument is not floating point\n");
  372.             f2 = 0.0;
  373.         }
  374.         f3 = f1 * f2;
  375.     }
  376.     else
  377.     {
  378.         xtbl->showMsg("Wrong number of arguments\n");
  379.         f3 = 0.0;
  380.     }
  381.  
  382.     // Allocate memory for long double return value
  383.     returnFloat = (long double**) xtbl->mem_New(sizeof(long double), FALSE);
  384.     if (returnFloat != NULL)
  385.     {
  386.         // Setup return value
  387.         **returnFloat = f3;
  388.         argp[0].ty = TY_FLOAT;
  389.         argp[0].it = (long) returnFloat;
  390.     }
  391.                 
  392.     return (0);
  393. }
  394.  
  395. /*
  396. ------------------------------------------------------------------------------
  397. FUNCTION        ||      _widget_mGlobals
  398.  
  399. Sample code to Read and Modify global variables
  400. ------------------------------------------------------------------------------
  401. */
  402.  
  403. long __far __pascal __export _widget_mGlobals(
  404.     LxProcTablePtr xtbl, LxMemHandle hWidget)
  405. {
  406.     LxMemHandle hdl;
  407.  
  408.     LogMessage( xtbl, "\nTest of Get/Set Lingo Globals.\n" );
  409.  
  410.     hdl = xtbl->GetLingoGlobal( "gTest" );
  411.     LogMessage( xtbl, "GetLingoGlobal(gTest)=%s\n", *hdl );
  412.     LogMessage( xtbl, "Expected value=<old value>\n");
  413.     xtbl->mem_Dispose( hdl );
  414.  
  415.     hdl = xtbl->string_New("<new value>");
  416.     xtbl->SetLingoGlobal( "gTest", hdl );
  417.     LogMessage( xtbl, "SetLingoGlobal set to <new value>\n");
  418.     xtbl->mem_Dispose( hdl );
  419.  
  420.     hdl = xtbl->GetLingoGlobal( "gTest" );
  421.     LogMessage( xtbl, "GetLingoGlobal(gTest)=%s\n", *hdl );
  422.     LogMessage( xtbl, "Expected value=<new value>\n");
  423.     xtbl->mem_Dispose( hdl );
  424.  
  425.     return 0;
  426. }
  427.  
  428. /*
  429. ------------------------------------------------------------------------------
  430. FUNCTION        ||      _widget_mSymbols
  431.  
  432. Sample code to convert Symbols to IDs and back again.
  433. ------------------------------------------------------------------------------
  434. */
  435.  
  436. long __far __pascal __export _widget_mSymbols(
  437.     LxProcTablePtr xtbl, LxMemHandle hWidget)
  438. {
  439.     long        id;
  440.     char        strBuf[256];
  441.  
  442.     LogMessage( xtbl,"\nTest of Symbol <--> ID # Conversion\n" );
  443.  
  444.     id = xtbl->ConvertStrToSymbol( "someSym" );
  445.     LogMessage( xtbl,"ConvertStrToSymbol(someSym) = id # %ld\n", id );
  446.  
  447.     xtbl->ConvertSymbolToStr( id, strBuf );
  448.     LogMessage( xtbl,"ConvertSymbolToStr(%ld) = %s\n", id, strBuf );
  449.     
  450.     return 0;
  451. }
  452.  
  453. /*
  454. ------------------------------------------------------------------------------
  455. FUNCTION        ||      _widget_mSendPerform
  456.  
  457. Sample code to illustrate usage of SendPerform callback
  458. ------------------------------------------------------------------------------
  459. */
  460.  
  461. long __far __pascal __export _widget_mSendPerform(
  462.     LxProcTablePtr xtbl, LxMemHandle hWidget)
  463. {
  464.     LxValue     args[4];
  465.  
  466.     args[1].ty = TY_STRING_PTR;
  467.     args[1].it = (long) "mAdd";
  468.     args[2].ty = TY_LONGINT;
  469.     args[2].it = 2;
  470.     args[3].ty = TY_LONGINT;
  471.     args[3].it = 3;
  472.  
  473.     // Send "mAdd, 2, 3" message to myself
  474.     xtbl->SendPerform( 3, &args[0],  hWidget );
  475.  
  476.     LogMessage( xtbl,"\nSend mAdd, 2, 3 message to self.\n" );
  477.     LogMessage( xtbl,"Expected Result:  Type=4, Value=5\n" );
  478.     LogMessage( xtbl,"Actual Result:    Type=%d, Value=%ld\n", 
  479.                 args[0].ty, args[0].it );
  480.  
  481.     return 0;
  482. }
  483.  
  484. /*
  485. ------------------------------------------------------------------------------
  486. FUNCTION        ||      _widget_mFactory
  487.  
  488. Sample code to illustrate usage of FindFactory callback
  489. ------------------------------------------------------------------------------
  490. */
  491.  
  492. long __far __pascal __export _widget_mFactory(
  493.     LxProcTablePtr xtbl, LxMemHandle hWidget)
  494. {
  495.     LxMemHandle hdl;
  496.  
  497.     hdl = xtbl->FindFactory( "FileIO" );
  498.     // Display object handle address:
  499.     LogMessage( xtbl, "\nTest of FindFactory callback.  Returned object\n" );
  500.     LogMessage( xtbl, "handle for FileIO = %lx\n", hdl );
  501.  
  502.     return 0;
  503. }
  504.  
  505.